# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Submódulo modelo                           ##
 ##   @ Módulo productos                         ##
 ##                                              ##
 ##   de la línea Básicos                        ##
 ##   de Críptidos Digitales                     ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

# print (0), "  productos.manejador   begin"

import sys
import datetime
from decimal import Decimal as dec

import man
# from man import Acepcion, Atributo, Entidad, AtributoProducto, Producto, Rol
from man import *

# import sqlalchemy
# from sqlalchemy import Table, Column, DateTime, Integer, Numeric, String, Unicode, ForeignKey
# from sqlalchemy.orm import mapper, relation, backref, sessionmaker
from sqlalchemy.sql import func

controller = None

# print (0), "  productos.manejador   definitions"


def acepcionAuxiliarExiste(**filtros):
    registro = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.rol_id != controller.app.holder.id).filter(Acepcion.status==u'actual').first()
    return registro


def acepcionExiste(**filtros):
    m = "productos.manejador.acepcionExiste()"

    if 'codigo' in filtros.keys():
        registro = man.session().query(Acepcion).filter(Acepcion.codigo==filtros['codigo']).filter(Acepcion.rol_id==filtros['rol_id']).filter(Acepcion.status==u'actual').one()
    else:
        registro = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.rol_id==filtros['rol_id']).filter(Acepcion.status==u'actual').first()
        if registro:
            return registro
        else:
            return None
    return registro


def agrega(datos):
    m = "productos.manejador.agrega()"
    # print (1), m, datos

    ## CLASIFICACIÓN
    if not 'clasificacion_id' in datos.keys():
        if 'clasificacion' in datos.keys():
            clasificacion = atributoI(grupo=u'clasificacionProducto', nombre=datos['clasificacion'])
            # try:
                # clasificacion = session().query(Atributo).filter(Atributo.grupo==u'clasificacionProducto').filter(Atributo.nombre==datos['clasificacion']).one()
            # except:
                # clasificacion = Atributo(grupo=u'clasificacionProducto', nombre=datos['clasificacion'])
                # man.session().add(clasificacion)
                # man.session().flush()
            datos['clasificacion_id'] = clasificacion.id

    producto = Producto(clasificacion_id=datos['clasificacion_id'], tipo_id=datos['tipo_id'], unidad_id=datos['unidad_id'], minimo=datos['minimo'], maximo=datos['maximo'], actual=datos['actual'], impuesto=datos['impuesto'], margen=datos['margen'], costopromedio=datos['costopromedio'])
    man.session().add(producto)
    man.session().flush()

    ## LINEA
    if 'linea_id' not in datos.keys():
        if 'linea' in datos.keys():
            linea = atributoI(grupo=u'líneaProducto', nombre=datos['linea'])
            datos['linea_id'] = linea.id

    if datos['linea_id']:
        atributoProducto = atributoProductoI(producto_id=producto.id, nombre=u'línea', atributo_id=datos['linea_id'], status=u'actual')
        man.session().add(atributoProducto)
        man.session().flush()



    ## Acepcion local
    acepcion = Acepcion(producto_id=producto.id, rol_id=controller.app.holder.id, codigo=datos['codigo'], nombre=datos['nombre'], costo=datos['costopromedio'], descuentoindividual=datos['descuentoIndividual'], descuentogeneral=dec("0"), status=u'actual', fechaalta=datetime.datetime.today())
    man.session().add(acepcion)
    man.session().flush()

    ## Acepciones externas
    acepciones = []
    print datos['acepciones']
    for index, key in enumerate(datos['acepciones'].keys()):
        print key
        data = datos['acepciones'][key]
        acepciones.append(Acepcion(producto_id=producto.id, rol_id=data['rol_id'], codigo=data['codigo'], nombre=data['nombre'], costo=data['costo'], descuentoindividual=dec("0"), descuentogeneral=data['descuentogeneral'], referencia=u"%s" % data['referencia'], status=u'actual', fechaalta=datetime.datetime.today()))
        man.session().add(acepciones[index])

    ## Precio 1
    atributo = atributoProductoI(producto_id=producto.id, nombre=u'precio', valor=u'%s' % datos['precio1'], factor1=u'%s' % datos['ajuste1'], factor2=u'%s' % datos['descuento1'], atributo_id=datos['referencia1'], status=u'actual', fechaalta=datetime.datetime.today())
    producto.atributos.append(atributo)
    man.session().add(atributo)
    man.session().flush()

    ## Precio 2
    if 'precio2' in datos.keys():
        atributo = atributoProductoI(producto_id=producto.id, nombre=u'precio', valor=u'%s' % datos['precio2'], factor1=u'%s' % datos['ajuste2'], factor2=u'%s' % datos['descuento2'], atributo_id=datos['referencia2'], status=u'actual', fechaalta=datetime.datetime.today())
        producto.atributos.append(atributo)
        man.session().add(atributo)

    man.session().commit()

    return acepcion.id


def dameAcepcion(**filtros):
    if filtros.has_key('id'):
        registro = man.session().query(Acepcion).filter(Acepcion.id==filtros['id']).one()
    elif filtros.has_key('codigo'):
        if filtros.has_key('rol_id'):
            registro = man.session().query(Acepcion).filter(Acepcion.rol_id==filtros['rol_id']).filter(Acepcion.codigo==filtros['codigo']).filter(Acepcion.status==u'actual').first()
        else:
            registro = man.session().query(Acepcion).filter(Acepcion.rol_id==controller.app.holder.id).filter(Acepcion.codigo==filtros['codigo']).filter(Acepcion.status==u'actual').first()
    elif filtros.has_key('producto_id'):
        if 'rol_id' in filtros.keys():
            registro = man.session().query(Acepcion).join(Producto).filter(Producto.id==filtros['producto_id']).filter(Acepcion.rol_id==filtros['rol_id']).filter(Acepcion.status==u'actual').one()
        else:
            registro = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.rol_id!=controller.app.holder.id).filter(Acepcion.status==u'actual').one()
    return registro


def dameAcepciones(**filtros):
    m = "productos.manejador.dameAcepciones()"

    try:
        if 'status' not in filtros.keys():
            filtros['status'] = u'actual'
        if 'producto_id' in filtros.keys():
            # registros = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.status==u'actual').all()
            registros = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.status==u'actual').order_by(Acepcion.rol_id).all()
        else:
            if 'clasificacion_id' in filtros.keys():
                clasificacionId = filtros.pop('clasificacion_id')
                if 'tipo_id' in filtros.keys():
                    tipoId = filtros.pop('tipo_id')
                    registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).filter_by(**filtros).join(Producto).filter(Producto.clasificacion_id==clasificacionId).filter(Producto.tipo_id==tipoId).all()
                else:
                    registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).filter_by(**filtros).join(Producto).filter(Producto.clasificacion_id==clasificacionId).all()
            else:
                if 'tipo_id' in filtros.keys():
                    tipoId = filtros.pop('tipo_id')
                    registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).filter_by(**filtros).join(Producto).filter(Producto.tipo_id==tipoId).all()
                else:
                    registros = man.session().query(Acepcion).filter_by(**filtros).all()
        return registros
    except:
        print (2), m
        print filtros


def dameAtributo(**filtros):
    f=g
    #! obsoleto, use atributoI()

    if 'id' in filtros.keys():
        registro = man.session().query(Atributo).filter(Atributo.id==filtros['id']).one()
    elif 'valor' in filtros.keys():
        registro = man.session().query(Atributo).filter(Atributo.propietario==filtros['propietario']).filter(Atributo.nombre==filtros['nombre']).filter(Atributo.valor==filtros['valor']).one()
    else:
        registro = man.session().query(Atributo).filter(Atributo.propietario==filtros['propietario']).filter(Atributo.nombre==filtros['nombre']).one()
    return registro


def atributoProductoI(**datos):
    m = "productos.manejador.atributoProductoI()"
    # print (1), m, datos

    if 'status' not in datos.keys():
        datos['status'] = u'actual'

    atributo = man.session().query(AtributoProducto).filter_by(**datos).first()

    if not atributo:
        if 'id' in datos.keys():
            atributo = man.session().query(AtributoProducto).filter(AtributoProducto.id==datos.pop('id')).first()

        if not atributo:
            if 'atributo_id' in datos.keys():
                atributo = man.session().query(AtributoProducto).filter(AtributoProducto.producto_id==datos['producto_id']).filter(AtributoProducto.nombre==datos['nombre']).filter(AtributoProducto.atributo_id==datos['atributo_id']).filter(AtributoProducto.status==datos['status']).first()

        if not atributo:
            """ Si no es modificación, es alta """
            atributo = AtributoProducto(**datos)
        else:
            atributo.setData(**datos)

        man.session().add(atributo)
        man.session().commit()

    return atributo


def atributoProductoExiste(**filtros):
    atributo = man.session().query(AtributoProducto).filter_by(**filtros).first()
    if atributo:
        return True
    else:
        return False


def capturaActualPermitida():
    if atributoI(grupo=u'producto', nombre=u'capturaActualPermitida').valor == u"1":
        return True
    else:
        return False


def capturaLineaHabilitada():
    if atributoI(grupo=u'producto', nombre=u'capturaLineaHabilitada').valor == u'1':
        return True
    else:
        return False


def capturaClasificacionObligatoria():
    if atributoI(grupo=u'producto', nombre=u'capturaClasificacionObligatoria').valor == u"1":
        return True
    else:
        return False


def clasificacion(**filtros):
    filtros['grupo'] = u'clasificacionProducto'
    registro = atributoI(**filtros)
    return registro


def clasificaciones():
    registros = atributosI(grupo=u'clasificacionProducto', order=u'nombre')
    return registros


def codigoExiste(codigo):           # print "productos.manejador.codigoExiste()"
    if man.session().query(Acepcion).filter(Acepcion.rol_id==controller.app.holder.id).filter(Acepcion.codigo==codigo).first():
        return True
    else:
        return False


def dameDescuentoEnabled():
    registro = atributoI(grupo=u'producto', nombre=u'descuentoEnabled')
    return registro.valor == u'1'

def dameImpuestoDefault():
    f=g

    registro = atributoI(grupo=u'sistema', nombre=u'impuestoGeneral')
    return dec(registro.valor)

def dameImpuestoEnabled():
    registro = atributoI(grupo=u'producto', nombre=u'impuestoEnabled')
    return registro.valor == u'1'

def lineas():
    registros = atributosI(grupo=u'líneaProducto', order=u'nombre')
    return registros


def dameOrigen(filtros):
    registro = rol(id=filtros['id'])
    return registro


def dameProducto(**filtros):
    m = "productos.manejador.dameProducto()"

    if 'id' in filtros.keys():
        try:
            registro = man.session().query(Producto).filter(Producto.id==filtros['id']).one()
        except:
            print (2), m, '!filtros: ', filtros
    return registro


def dameProductos():
    registros = man.session().query(Producto).all()
    return registros


def proveedor(**filtros):
    filtros['tipo_id'] = atributoI(grupo=u'tipoRol', nombre=u'proveedor').id
    registro = rolI(**filtros)
    return registro


def proveedores(**filtros):
    filtros['tipo_id'] = atributoI(grupo=u'tipoRol', nombre=u'proveedor').id
    registros = man.session().query(Rol).filter_by(**filtros).join(Entidad).order_by(Entidad.nombre).all()
    return registros


# def dameRangosPrecio():
    # registros = atributosI(grupo=u'rangoPrecioProducto', order=u'referencia')
    # return registros

def rangosPrecio(**filtros):
    if 'activo' in filtros.keys():
        activo = filtros.pop('activo')
        if activo:
            registros = man.session().query(Atributo).filter(Atributo.grupo==u'rangoPrecioProducto').filter(Atributo.referencia.like(u'%%a%%')).order_by(Atributo.referencia).all()
        else:
            registros = man.session().query(Atributo).filter(Atributo.grupo==u'rangoPrecioProducto').filter(Atributo.referencia.like(u'%%i%%')).order_by(Atributo.referencia).all()
    else:
        registros = man.session().query(Atributo).filter(Atributo.grupo==u'rangoPrecioProducto').order_by(Atributo.referencia).all()
    return registros



def dameTipo(**filtros):
    f=g
    # if 'id' in filtros.keys():
        # registro = atributoI(id=filtros['id'])
    # elif 'valor' in filtros.keys():
        # registro = atributoI(grupo=u'producto', nombre=u'tipo', valor=filtros['valor'])
    # return registro

def tipo(**filtros):
    filtros['grupo']=u'tipoProducto'
    registro = atributoI(**filtros)
    return registro

def tipoDefault():
    registro = atributoI(grupo=u'tipoProducto', valor=u'default')
    return registro

def tipos():
    registros = atributosI(grupo=u'tipoProducto')
    return registros


def unidad(**filtros):
    filtros['grupo'] = u'unidad'
    registro = atributoI(**filtros)
    # if 'id' in filtros.keys():
        # registro = atributoI(id=filtros['id'])
    # elif 'valor' in filtros.keys():
        # registro = atributoI(grupo=u'unidad', nombre=filtros['nombre'])
    return registro

def unidadDefault():
    registro = atributoI(grupo=u'unidad', valor=u'default')
    return registro

def unidades():
    registros = atributosI(grupo=u'unidad')
    return registros


def dameUno(**filtros):
    f=g

    if 'id' in filtros.keys():
        registro = man.session().query(Acepcion).filter(Acepcion.id==filtros['id']).one()
    elif 'producto_id' in filtros.keys():
        registro = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).one()
    return registro


def dameVarios(**filtros):
    m = "productos.manejador.dameVarios()"

    try:
        if 'status' not in filtros.keys():
            filtros['status'] = u'actual'
        if filtros.has_key('origen'):
            f=g
            if filtros.has_key('tipo'):
                registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).filter(Acepcion.rol_id==filtros['origen']).join(Acepcion.producto_id).filter(Producto.tipo==filtros['tipo']).all()
            else:
                registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).filter(Acepcion.rol_id==filtros['origen']).all()
        elif 'producto_id' in filtros.keys():
            registros = man.session().query(Acepcion).filter(Acepcion.producto_id==filtros['producto_id']).filter(Acepcion.status==filtros['status']).order_by(Acepcion.rol_id).all()
        else:
            f=g
            if filtros.has_key('tipo'):
                registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).join(Acepcion.producto_id).filter(Producto.tipo==filtros['tipo']).all()
            else:
                registros = man.session().query(Acepcion).filter(Acepcion.id!=controller.app.holder.id).all()
        return registros
    except:
        print (2), m
        print filtros


# def datosConsulta():
    # datos = man.session().query(Producto).order_by(Producto.id).all()
    # for instance in datos:
        # print ")", instance.nombre.encode('utf-8'), "|", instance.codigo.encode('utf-8'), "("
    # return datos


def elimina(**filtros):
    acepcion = man.session().query(Acepcion).filter(Acepcion.id==filtros['id']).one()

    acepciones = dameAcepciones(producto_id=acepcion.producto_id)

    for acepcion in acepciones:
        acepcion.fechabaja = datetime.datetime.today()
        acepcion.status = u'eliminada'

    producto = acepcion.producto

    producto.fechabaja = datetime.datetime.today()
    producto.status = u'eliminado'

    man.session().commit()


def modifica(datos):
    m = "productos.manejador.modifica()"
    print (1), m, datos

    """ La acepciones son accesadas normalmente por rol_id y producto_id, por
    lo que puede exinirse a id de su rol identificatorio y manejarse el
    archivado del registro obsoleto, despues de crearse el registro nuevo.
    El producto no puede cambiar de id por lo que el archivado se hace en el
    registro nuevo y el registro viejo actualiza su contenido
    HABRÁ QUE ANALIZAR SI LAS ACEPCIONES DEBIERAN SEGUIR ESTE COMPORTAMIENTO."""

    ## CLASIFICACIÓN
    if not 'clasificacion_id' in datos.keys():
        if 'clasificacion' in datos.keys():
            try:
                clasificacion = session().query(Atributo).filter(Atributo.grupo==u'clasificacionProducto').filter(Atributo.nombre==datos['clasificacion']).one()
            except:
                clasificacion = Atributo(grupo=u'clasificacionProducto', nombre=datos['clasificacion'])
                man.session().add(clasificacion)
                man.session().flush()
            datos['clasificacion_id'] = clasificacion.id

    producto = dameProducto(id=datos['id'])

    changed = False

    if producto.tipo_id != datos['tipo_id'] or producto.clasificacion_id != datos['clasificacion_id'] or producto.unidad_id != datos['unidad_id'] or producto.minimo != datos['minimo'] or producto.maximo != datos['maximo'] or producto.actual != datos['actual'] or producto.costopromedio != datos['costopromedio'] or producto.impuesto != datos['impuesto'] or producto.margen != datos['margen']:

        productoNew = Producto(tipo_id=producto.tipo_id, clasificacion_id=producto.clasificacion_id, unidad_id=producto.unidad_id, minimo=producto.minimo, maximo=producto.maximo, actual=producto.actual, costopromedio=producto.costopromedio, impuesto=producto.impuesto, margen=producto.margen, status=u'obsoleto', fechaalta=producto.fechaalta, fechabaja=datetime.datetime.today())
        man.session().add(productoNew)
        man.session().flush()

        producto.tipo_id = datos['tipo_id']
        producto.clasificacion_id = datos['clasificacion_id']
        producto.unidad_id = datos['unidad_id']
        producto.minimo = datos['minimo']
        producto.maximo = datos['maximo']
        producto.actual = datos['actual']
        producto.costopromedio = datos['costopromedio']
        producto.impuesto = datos['impuesto']
        producto.margen = datos['margen']
        producto.status = u'activo'
        # producto.fechaalta = datetime.datetime.today()

        man.session().add(producto)
        man.session().flush()

    ## LINEA
    if 'linea_id' not in datos.keys():
        if 'linea' in datos.keys():
            linea = atributoI(grupo=u'líneaProducto', nombre=datos['linea'])
            datos['linea_id'] = linea.id

    ## Linea
    if datos['linea_id']:
        # Se ha limitado el uso a una sola línea
        atributoProducto = atributoProductoI(producto_id=producto.id, nombre=u'línea',atributo_id=datos['linea_id'])

    ## Acepciones
    acepcion = acepcionI(producto_id=datos['id'], rol_id=controller.app.holder.id, status=u'actual')

    if acepcion:
        if acepcion.codigo!=datos['codigo'] or acepcion.nombre!=datos['nombre'] or acepcion.costo!=datos['costopromedio']:
            # No se usa acepcionI porque existen otros registros de obsolescencia
            acepcionNew = Acepcion(producto_id=acepcion.producto_id, rol_id=acepcion.rol_id, codigo=acepcion.codigo, nombre=acepcion.nombre, costo=acepcion.costo, descuentoindividual=acepcion.descuentoindividual, descuentogeneral=acepcion.descuentogeneral, referencia=acepcion.referencia, status=u'obsoleta', fechaalta=acepcion.fechaalta, fechabaja=datetime.datetime.today())
            man.session().add(acepcionNew)
            man.session().flush()

            acepcion.codigo = datos['codigo']
            acepcion.nombre = datos['nombre']
            acepcion.costo = datos['costopromedio']
            # acepcion.fechaalta = datetime.datetime.today()
            acepcion.status = u'actual'

            man.session().flush()

    ## Si hay acepciones registradas que no están en los datos recibidos, fueron eliminadas
    # roles_idOld = [x.rol_id for x in dameAcepciones('producto_id'=datos['id'])]
    # roles_idOld.pop(roles_idOld.index(-1))

    acepciones = []
    acepciones2 = []

    print 234, datos['acepciones']

    for index, acepcionKey in enumerate(datos['acepciones'].keys()):
        datos['acepciones'][acepcionKey]['producto_id'] = producto.id
        acepcionx = acepcionI(**datos['acepciones'][acepcionKey])

        # if acepcionx['new'] != acepcionx['old']:
            # acepcion = acepcionExiste(rol_id=acepcionx['rol_id'], producto_id=datos['id'], status=u'actual')

            # acepciones.append(acepcion)
            # createNew = True
            # if acepciones[index]:
                # Si ya existe la acepcion
                # if acepciones[index].codigo != acepcionx['codigo'] or acepciones[index].nombre != acepcionx['nombre'] or acepciones[index].costo != acepcionx['costo'] or acepciones[index].descuentogeneral != acepcionx['descuento'] or acepciones[index].referencia != acepcionx['referencia']:
                    # Si hay algún cambio
                    # acepciones[index].fechabaja = datetime.datetime.today()
                    # acepciones[index].status = u'obsoleta'
                # else:
                    # Si no hay cambios
                    # createNew = False
            # if createNew:
                # acepciones2.append(Acepcion(producto_id=datos['id'], rol_id=acepcionx['rol_id'], codigo=acepcionx['codigo'], nombre=acepcionx['nombre'], costo=acepcionx['costo'], descuentogeneral=acepcionx['descuento'], status=u'actual', referencia="%s" % acepcionx['referencia'], fechaalta=datetime.datetime.today()))
                # man.session().add(acepciones2[len(acepciones2)-1])

                # man.session().flush()

    ## Checando las acepciones eliminadas
    # for roles_id in roles_idOld:





    # if 'acepcion1old' in datos.keys():
        # acepcion1old = datos['acepcion1old']
        # changed = False
        # if 'acepcion1' in datos.keys():
            # if acepcion1old.rol_id != datos['acepcion1']['rol_id']:
                # changed = True
            # if acepcion1old.codigo != datos['acepcion1']['codigo']:
                # changed = True
            # if acepcion1old.nombre != datos['acepcion1']['nombre']:
                # changed = True
            # if acepcion1old.costo != datos['acepcion1']['costo']:
                # changed = True
            # if acepcion1old.descuentogeneral != datos['acepcion1']['descuentoGeneral']:
                # changed = True
            # if acepcion1old.referencia != datos['acepcion1']['referencia']:
                # changed = True

            # if changed:
                # acepcion12 = Acepcion(producto_id=datos['id'], rol_id=datos['acepcion1']['rol_id'], codigo=datos['acepcion1']['codigo'], nombre=datos['acepcion1']['nombre'], costo=datos['acepcion1']['costo'], descuentogeneral=datos['acepcion1']['descuentoGeneral'], status=u'actual', referencia=datos['acepcion1']['referencia'], fechaalta=datetime.datetime.today())
                # man.session().add(acepcion12)
        # else:
            # changed = True
        # if changed:
            # acepcion1old.fechabaja = datetime.datetime.today()
            # acepcion1old.status = u'obsoleta'

    # elif 'acepcion1' in datos.keys():
        # acepcion12 = Acepcion(producto_id=datos['id'], rol_id=datos['acepcion1']['rol_id'], codigo=datos['acepcion1']['codigo'], nombre=datos['acepcion1']['nombre'], costo=datos['acepcion1']['costo'], descuentogeneral=datos['acepcion1']['descuentoGeneral'], status=u'actual', referencia=datos['acepcion1']['referencia'], fechaalta=datetime.datetime.today())
        # man.session().add(acepcion12)

    ## Atributos
    print (2), m, datos

    ## Precios
    for price in datos['prices']:
        atributo = atributoProductoI(producto_id=datos['id'], nombre=u'precio', atributo_id=price['referencia'])

        if atributo:
            if dec(atributo.valor) != price['value'] or dec(atributo.factor1) != price['adjust'] or dec(atributo.factor2) != price['discount']:
                fechaActual = datetime.datetime.today()
                atributoNew = atributoProductoI(producto_id=atributo.producto_id, nombre=atributo.nombre, valor=atributo.valor, factor1=atributo.factor1, factor2=atributo.factor2, atributo_id=atributo.atributo_id, referencia=atributo.referencia, usuario=atributo.usuario, status=u'obsoleto', fechaalta=atributo.fechaalta, fechabaja=fechaActual)
            atributo.valor = unicode( price['value'] )
            atributo.factor1 =unicode( price['adjust'] )
            atributo.factor2 = unicode( price['discount'] )
            atributo.fechaalta = fechaActual

            man.session().flush()

        else:
            """Este código se incluye por compatibilidad con versiones anteriores
                que no manejaban este registro"""
            atributoNew = atributoProductoI(producto_id=datos['id'], nombre=u'precio', valor=u'%s' % price['valor'], factor1=u'%s' % price['adjust'], factor2=u'%s' % price['discount'], atributo_id=datos['referencia1'], status=u'actual', fechaalta=datetime.datetime.today())



    """
    ## Precio 1
    atributo = atributoProductoI(producto_id=datos['id'], nombre=u'precio', atributo_id=datos['referencia1'])
    print 111, atributo

    if atributo:
        if dec(atributo.valor) != datos['precio1'] or dec(atributo.factor1) != datos['ajuste1'] or dec(atributo.factor2) != datos['ajuste1']:
            fechaActual = datetime.datetime.today()
            atributoNew = atributoProductoI(producto_id=atributo.producto_id, nombre=atributo.nombre, valor=atributo.valor, factor1=atributo.factor1, factor2=atributo.factor2, atributo_id=atributo.atributo_id, referencia=atributo.referencia, usuario=atributo.usuario, status=u'obsoleto', fechaalta=atributo.fechaalta, fechabaja=fechaActual)
            # atributoNew.status = u'obsoleto'

            atributo.valor = unicode( datos['precio1'] )
            atributo.factor1 =unicode( datos['ajuste1'] )
            atributo.factor2 = unicode( datos['descuento1'] )
            atributo.fechaalta = fechaActual

            man.session().flush()
    else:
        '''Este código se incluye por compatibilidad con versiones anteriores
            que no manejaban este registro'''
        atributoNew = atributoProductoI(producto_id=datos['id'], nombre=u'precio', valor=u'%s' % datos['precio1'], factor1=u'%s' % datos['ajuste1'], factor2=u'%s' % datos['descuento1'], atributo_id=datos['referencia1'], status=u'actual', fechaalta=datetime.datetime.today())
        # man.session().add(atributoNew)
        # man.session().flush()


    ## Precio 2
    if 'referencia2' in datos.keys():
        if atributoProductoExiste(producto_id=datos['id'], nombre=u'precio', atributo_id=datos['referencia2']):
            atributo = atributoProductoI(producto_id=datos['id'], nombre=u'precio', atributo_id=datos['referencia2'])
            print 222, atributo
        # if atributo:
            if dec(atributo.valor) != datos['precio2'] or dec(atributo.factor1) != datos['ajuste2'] or dec(atributo.factor2) != datos['ajuste2']:
                fechaActual = datetime.datetime.today()
                atributoNew = atributoProductoI(producto_id=atributo.producto_id, nombre=atributo.nombre, valor=atributo.valor, factor1=atributo.factor1, factor2=atributo.factor2, atributo_id=atributo.atributo_id, referencia=atributo.referencia, usuario=atributo.usuario, status=u'obsoleto', fechaalta=atributo.fechaalta, fechabaja=fechaActual)
                # man.session().add(atributoNew)

                atributo.valor = unicode(datos['precio2'])
                atributo.factor1 = unicode(datos['ajuste2'])
                atributo.factor2 = unicode(datos['descuento2'])
                atributo.fechaalta = fechaActual

                man.session().flush()
        else:
            atributoNew = atributoProductoI(producto_id=datos['id'], nombre=u'precio', valor=u'%s' % datos['precio2'], factor1=u'%s' % datos['ajuste2'], factor2=u'%s' % datos['descuento2'], atributo_id=datos['referencia2'], status=u'actual', fechaalta=datetime.datetime.today())
            # man.session().add(atributo)
            # man.session().flush()
    """

    try:
        man.session().commit()
    except:
        print "puaj"
        man.session().rollback()

    return


def totalDeProductos():
    return man.session().query(func.count(Producto.id)).one()[0]

def totalDeProveedores():
    tipo_id = atributoI(grupo=u'tipoRol', nombre=u'proveedor').id
    return man.session().query(func.count(Rol.id)).filter(Rol.tipo_id==tipo_id).one()[0]


def usarCodigoSecundario():
    return atributoI(grupo=u'producto', nombre=u'usarCódigoSecundario').valor == '1'


def valida(datos, modo):            # print "productos.manejador.valida()"
    """
        Realiza la validación de lógica de negocios
            La clasificación se recibe como una cadena para uniformizar el
            proceso de validación
    """
    valida = True
    mensajes = ""

    ## La validación de código se hace en la interfase

    ## Determinar si la clasificación ya existe, o es una nueva
    if 'clasificacion' in datos.keys():
        mensajes += u"La clasificación no existe, se creará\n"

    return valida, mensajes





def inicializa():
    try:
        version = int(atributoI(grupo=u'producto', nombre=u'versionBasedatos').valor)
    except:
        print "Inicializando Base de datos para productos"

        registros = [
            {'code':1605, 'grupo':u'producto', 'nombre':u'capturaActualPermitida', 'valor':u'0'},
            {'code':1607, 'grupo':u'producto', 'nombre':u'capturaLineaHabilitada', 'valor':u'1'},
            {'code':1609, 'grupo':u'producto', 'nombre':u'capturaClasificacionObligatoria', 'valor':u'1'},
            {'code':1611, 'grupo':u'producto', 'nombre':u'usarCódigoSecundario', 'valor':u'0'},

            {'code':1617, 'grupo':u'producto', 'nombre':u'descuentoEnabled', 'valor':u'1'},
            {'code':1619, 'grupo':u'producto', 'nombre':u'impuestoEnabled', 'valor':u'1'},

            {'code':1623, 'grupo':u'producto', 'nombre':u'recalcularPrecioAlComprar', 'valor':u'1'},
            {'code':1625, 'grupo':u'producto', 'nombre':u'sentidoDeCambio', 'valor':u'+/-'},
            {'code':1627, 'grupo':u'producto', 'nombre':u'margenDeCambio', 'valor':u'5'},

            {'code':1643, 'grupo':u'tipoProducto', 'nombre':u'Artículo', 'valor':u'default'},
            {'code':1645, 'grupo':u'tipoProducto', 'nombre':u'Equipo'},
            {'code':1647, 'grupo':u'tipoProducto', 'nombre':u'Parte'},
            {'code':1649, 'grupo':u'tipoProducto', 'nombre':u'Ensamble'},
            {'code':1651, 'grupo':u'tipoProducto', 'nombre':u'Servicio'},

            {'code':1661, 'grupo':u'rangoPrecioProducto', 'nombre':u'General', 'valor':u'default', 'referencia':u'1a'},
            {'code':1663, 'grupo':u'rangoPrecioProducto', 'nombre':u'Preferente', 'referencia':u'2i'},

            {'code':1673, 'grupo':u'unidad', 'nombre':u'-', 'referencia':u'-'},
            {'code':1675, 'grupo':u'unidad', 'nombre':u'Pieza', 'valor':u'default', 'referencia':u'pza'},
            {'code':1677, 'grupo':u'unidad', 'nombre':u'Metro', 'referencia':u'mt'},
            {'code':1679, 'grupo':u'unidad', 'nombre':u'Kilogramo', 'referencia':u'kg'}
        ]

        for registro in registros:
            atributoI(**registro)

        atributoI(grupo=u'producto', nombre=u'versionBasedatos', valor=u'11')
        version = 11



# print (0), "  productos.manejador   end"


"""
test

Un producto es una entidad única e independiente.

Puede tener algunos atributos que varían de acuerdo a la percepción de otros,
en este caso los proveedores y clientes. Ej código, nombre, clasificación,
costo.

Estos datos se registran en una tabla satelite, indicando de quien es la
percepción. De esta manera se mantiene la integridad de los datos de producto.


Determinación de códigos de productos.
    Códigos locales
    Cada vez hay más globalización en productos, lo que genera uniformidad de
    información, muchos productos tienen códigos usados internacionalmente,
    se recomienda usar estos estandares, si se requiere una diferenciación
    extra se recomienda agregar caracteres al estandar.
    Si no se cuenta con un código estándar, se recomienda usar el código del
    fabricante.

    Códigos externos
    Se usa el proporcionado por el proveedor. No se recomienda cambiarlo,
    porque se generarían errores en la comunicación con el proveedor.
    Si el proveedor cambia sus datos, EB puede registrar esos cambios sin
    problemas, sin perder información ya registrada.




Issues

Precio2 may lead to crash if capture hability is changed. Design time.

"""



